home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / ABERMUD.ZIP / SUPPORT.C < prev    next >
C/C++ Source or Header  |  1989-07-08  |  5KB  |  361 lines
  1. #include "object.h"
  2. #include <stdio.h>
  3. #include "files.h"
  4.  
  5. extern FILE* openlock();
  6.  /*
  7.  
  8.  Some more basic functions
  9.  
  10.  
  11.  Note
  12.  
  13.  state(obj)
  14.  setstate(obj,val)
  15.  destroy(obj)
  16.  
  17.  are elsewhere
  18.  
  19.  */
  20. extern OBJECT objects[];
  21.  
  22.  ocarrf(ob)
  23.     {
  24.     extern long objinfo[];
  25.     return(objinfo[4*ob+3]);
  26.     }
  27.  
  28.  setocarrf(ob,v)
  29.     {
  30.     extern long objinfo[];
  31.     objinfo[4*ob+3]=v;
  32.     }
  33.  
  34.  oloc(ob)
  35.     {
  36.     extern long objinfo[];
  37.     return(objinfo[4*ob]);
  38.     }
  39.  
  40.  setoloc(ob,l,c)
  41.     {
  42.     extern long objinfo[];
  43.     objinfo[4*ob]=l;
  44.     objinfo[4*ob+3]=c;
  45.     }
  46.  
  47.  
  48.  
  49.  ploc(chr)
  50.     {
  51.     extern long ublock[];
  52.     return((ublock[16*chr+4]));
  53.     }
  54.  
  55. char * pname(chr)
  56.     {
  57.     extern long ublock[];
  58.     return((char *)(ublock+16*chr));
  59.     }
  60.  
  61.  plev(chr)
  62.     {
  63.     extern long ublock[];
  64.     return(ublock[16*chr+10]);
  65.     }
  66.  
  67.  setplev(chr,v)
  68.     {
  69.     extern long ublock[];
  70.     ublock[16*chr+10]=v;
  71.     }
  72.  
  73.  pchan(chr)
  74.     {
  75.     extern long ublock[];
  76.     return(ublock[16*chr+4]);
  77.     }
  78.  
  79.  pstr(chr)
  80.     {
  81.     extern long ublock[];
  82.     return(ublock[16*chr+7]);
  83.     }
  84.  
  85.  setpstr(chr,v)
  86.     {
  87.     extern long ublock[];
  88.     ublock[16*chr+7]=v;
  89.     }
  90.  
  91.  pvis(chr)
  92.     {
  93.     extern long ublock[];
  94.     return(ublock[16*chr+8]);
  95.     }
  96.  
  97.  setpvis(chr,v)
  98.     {
  99.     extern long ublock[];
  100.     ublock[16*chr+8]=v;
  101.     }
  102.  
  103.  psex(chr)
  104.     {
  105.     extern long ublock[];
  106.     return(ublock[16*chr+9]%2);
  107.     }
  108.  
  109.  setpsex(chr,v)
  110.     {
  111.     extern long ublock[];
  112.     ublock[16*chr+9]&=~1;
  113.     ublock[16*chr+9]|=v;
  114.     }
  115. setpsexall(chr,v)
  116. long v;
  117. {
  118.     extern long ublock[];
  119.     ublock[16*chr+9]=v;
  120. }
  121.  
  122. psexall(chr)
  123. long chr;
  124. {
  125.     extern long ubklock[];
  126.     return(ublock[16*chr+9]);
  127. }
  128.  
  129. char * oname(ob)
  130.     {
  131.     extern OBJECT objects[];
  132.     return(objects[ob].o_name);
  133.     }
  134.  
  135. char * olongt(ob,st)
  136. {
  137.     extern OBJECT objects[];
  138.     return(objects[ob].o_desc[st]);
  139. }
  140.  
  141.  
  142.  omaxstate(ob)
  143.     {
  144.     extern OBJECT objects[];
  145.     return(objects[ob].o_maxstate);
  146.     }
  147.  
  148.  obflannel(ob)  /* Old version */
  149.     {
  150.     return(oflannel(ob));
  151.     }
  152.  oflannel(ob)
  153.     {
  154.     extern OBJECT objects[];
  155.     return(objects[ob].o_flannel);
  156.     }
  157.  
  158.  obaseval(ob)
  159.     {
  160.     extern OBJECT objects[];
  161.     return(objects[ob].o_value);
  162.     }
  163.  
  164.  isdest(ob)
  165.     {
  166.     if(otstbit(ob,0))return(1);
  167.     return(0);
  168.     }
  169.  
  170.  isavl(ob)
  171.     {
  172.     extern long mynum;
  173.     if(ishere(ob)) return(1);
  174.     return(iscarrby(ob,mynum));
  175.     }
  176.  
  177.  ospare(ob)
  178.     {
  179.     return(otstbit(ob,0)?-1:0);
  180.     }
  181.  
  182.  ppos(chr)
  183.     {
  184.     extern long ublock[];
  185.     return(ublock[16*chr+5]);
  186.     }
  187.  
  188.  setppos(chr,v)
  189.     {
  190.     extern long ublock[];
  191.     ublock[16*chr+5]=v;
  192.     }
  193.  
  194.  setploc(chr,n)
  195.     {
  196.     extern long ublock[];
  197.     ublock[16*chr+4]=n;
  198.     }
  199.  
  200.  pwpn(chr)
  201.     {
  202.     extern long ublock[];
  203.     return(ublock[16*chr+11]);
  204.     }
  205.  
  206.  setpwpn(chr,n)
  207.     {
  208.     extern long ublock[];
  209.     ublock[16*chr+11]=n;
  210.     }
  211.  
  212. ocreate(ob)
  213. {
  214. oclrbit(ob,0);
  215. }
  216.  
  217. syslog(args,arg1,arg2)
  218. char *args,*arg1,*arg2;
  219. {
  220. extern char *strchr();    
  221. extern char *ctime();
  222. long tm;
  223. FILE *x;
  224. char *z;
  225. time(&tm);
  226. z=ctime(&tm);
  227. *strchr(z,'\n')=0;
  228. x=openlock(LOG_FILE,"a");
  229. if(x==NULL) {loseme();crapup("Log fault : Access Failure"); }
  230. fprintf(x,"%s:  ",z);
  231. fprintf(x,args,arg1,arg2);
  232. fprintf(x,"\n");
  233. fclose(x);
  234. }
  235.  
  236. osetbit(ob,x)
  237. {
  238. extern long objinfo[];
  239. bit_set(&(objinfo[4*ob+2]),x);
  240. }
  241. oclearbit(ob,x)
  242. {
  243. extern long objinfo[];
  244. bit_clear(&(objinfo[4*ob+2]),x);
  245. }
  246. oclrbit(ob,x)
  247. {
  248. oclearbit(ob,x)
  249. ;
  250. }
  251. otstbit(ob,x)
  252. {
  253. extern long objinfo[];
  254. return(bit_fetch(objinfo[4*ob+2],x));
  255. }
  256. osetbyte(o,x,y)
  257. {
  258. extern long objinfo[];
  259. byte_put(&(objinfo[4*o+2]),x,y);
  260. }
  261. obyte(o,x)
  262. {
  263. extern long objinfo[];
  264. return(byte_fetch(objinfo[4*o+2],x));
  265. }
  266. ohany(mask)
  267. long mask;
  268. {
  269. extern long numobs;
  270. auto a;
  271. extern long mynum;
  272. a=0;
  273. mask=mask<<16;
  274. while(a<numobs)
  275. {
  276. if(((iscarrby(a,mynum))||(ishere(a,mynum)))&&(objinfo[4*a+2]&mask))return(1);
  277. a++;
  278. }
  279. return(0);
  280. }
  281.  
  282. phelping(x,y)
  283. {
  284. extern long ublock[];
  285. return(ublock[16*x+13]);
  286. }
  287.  
  288. setphelping(x,y)
  289. {
  290. extern long ublock[];
  291. ublock[16*x+13]=y;
  292. }
  293.  
  294.  
  295. ptothlp(pl)
  296. {
  297. int tot;
  298. extern long maxu;
  299. int ct=0;
  300. while(ct<maxu)
  301. {
  302. if(ploc(ct)!=ploc(pl)){ct++;continue;}
  303. if(phelping(ct)!=pl){ct++;continue;}
  304. return(ct);
  305. }
  306. return(-1);
  307. }
  308.  
  309.  
  310. psetflg(ch,x)
  311. long ch;
  312. long x;
  313. {
  314.     extern long ublock[];
  315.     ublock[16*ch+9]|=(1<<x);
  316. }
  317.  
  318. pclrflg(ch,x)
  319. long ch;
  320. long x;
  321. {
  322.     extern long ublock[];
  323.     ublock[16*ch+9]&=~(1<<x);
  324. }
  325.  
  326. /*Pflags
  327.  
  328. 0 sex
  329.  
  330. 1 May not be exorcised ok
  331.  
  332. 2 May change pflags ok
  333.  
  334. 3 May use rmedit ok
  335.  
  336. 4 May use debugmode ok
  337.  
  338. 5 May use patch 
  339.  
  340. 6 May be snooped upon
  341.  
  342. */
  343.  
  344. ptstbit(ch,x)
  345. long ch;
  346. long x;
  347. {
  348.     return(ptstflg(ch,x));
  349. }
  350.  
  351.  
  352. ptstflg(ch,x)
  353. long ch;
  354. long x;
  355. {
  356.     extern long ublock[];
  357.     extern char globme[];
  358.     if((x==2)&&(strcmp(globme,"Debugger")==0)) return(1<<x);
  359.     return(ublock[16*ch+9]&(1<<x));
  360. }
  361.